package com.itfenghuang.day14;

import java.io.File;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 *javase总复习
 */
public class  A06_总复习 {
    /**
     * 1.第一个周
     *  1).JDK JRE JVM关系
     *      jdk包含jre   jre包含jvm
     *  2).数据类型
     *      基本数据类型:byte short int long float double boolean char
     *      引用数据类型:类,接口,数组,枚举
     *  3).变量
     *      声明  初始化    int a=1;
     *      局部变量:方法内  格式: 数据类型 变量名=值;
     *      成员变量: 类中,方法之外  格式: 修饰符 数据类型 变量名=值;
     *  4).运算符
     *      1.算术运算符
     *          +-* / %
     *      2.比较运算符
     *          > <  >=  <= == !=
     *      3.逻辑运算符
     *          & | !  && 和||区别
     *      4.赋值运算符
     *       = += -+ *= /= %=
     *      5.位运算符 >>n右移 除以2^n     << 乘以2^n
     *          以最快的速度计算出8/2的值
     *            1000     100
     *      6.自增自减
     *          ++ --
     *      7.三元运算符
     *         int i= 表达式? 值1:值2;
     *  5).分支结构
     *      单分支 if(){} else if(){} ... else{}
     *      多分支: switch() case 1 case 2  ... default
     *          case穿透,  break
     *  6).循环结构
     *      for循环 明确循环次数
     *      while() 不明确循环次数
     *      do{}while()  先执行一次再判断
     *      break:退出循环
     *      continue: 中断当前循环,继续下次循环
     *  7).控制台输入
     *      Scanner
     *  8).Random
     *      生成一个随机数
     *      nextInt(int bound)
     *  9).数组
     *      容器,用来装数据,数组中没有方法
     *      数组的特点: 长度固定,存储相同的类型,基本引用即可存
     *      数组定义: 数据类型[] 变量名;
     *      初始化: 静态初始化: int[] arr={};
     *             动态初始化: int[] arr=new int[长度];
     *      遍历: 索引for,增强for
     *      排序: 冒泡,选择
     *          交换位置
     *  10).方法
     *      格式: public static 返回值类型 方法名(方法参数){方法体}
     *        return:可以结束一个方法
     *      作用: 提高代码复用性
     *  11).String
     *     不可变
     *     常用方法:split() replace() substring() contains() trim()
     *        isEmpty() length() toCharArray() charAt(int index)
     *        indexOf(int ch) toLowerCase() toUpperCase() startWith()
     *        endsWith() getBytes() lastIndexOf()
     *      底层使用char数组实现的
     *      题目: 138****8381   TMD  ***   验证码  abds 随机数
     *   12)jdbc初体验
     *      实现步骤
     *2.第二周
     *  1).面向对象
     *      1.面向对象和面向过程的区别
     *      2.类与对象
     *          类:
     *              格式 class 类名{}
     *              成员: 成员变量,成员方法,构造方法
     *          对象:
     *              创建对象: 类名 对象名 =new 类名(构造参数);
     *  2).面向对象三大特征
     *      1.封装
     *          private
     *         bean 标准的实体类: 成员变量私有化,空参+全参 getXXsetXX
     *      2.继承
     *          1).格式 class A extends B{}
     *          2).优缺点:
     *          3).父子类成员之间关系
     *              1.成员变量:  变量名相同/不同
     *              2.成员方法: 不同: 直接调用  方法名相同: 重写
     *                                          如何检验是否重写  @Override
     *                   Overload和Override的区别
     *              3.构造方法
     *                  super(); 调用父类空参构造
     *                  this(); 调用本类的构造
     *          4).特点:
     *              不可以多继承,可以多层继承,不可以循环继承
     *          5).this和super
     *              this:当前对象的引用
     *                  调用成员变量,成员方法,构造方法
     *              super:父类标识,可以理解父类对象
     *                  调用父类成员
     *          6).static
     *              静态修饰符
     *              修饰
     *                  成员变量:类变量  被该类所有对象共享
     *                  成员方法: 类名.调用
     *                  代码块: 静态代码块 类加载执行,并且只执行一次
     *          7).final
     *             最终不可变
     *             修饰:
     *              类: 不能被继承
     *              方法:不能被重写
     *              变量: 常量
     *          8).代码块
     *              格式: {}
     *              分类:
     *                  1.局部代码块
     *                      方法内  让变量更早的消失
     *                  2.构造代码块
     *                      类中,方法外
     *                      构造方法执行之前执行构造代码块
     *                      抽取多个构造方法相同的代码,提高代码的复用性
     *                  3.静态代码块
     *          9).抽象类
     *              1.有抽象方法的类
     *              2.抽象方法: 被abstract修饰的方法,没有方法体
     *              3.格式 : 抽象类: abstract class 类名{}
     *                      抽象方法: 修饰符 abstract 返回值类型 方法名(方法参数);
     *              4.特点:
     *                  1.不能被实例化
     *                  2.可以有普通方法,也可以有抽象方法
     *                  3.子类必须重写抽象类的抽象方法,否则子类必是抽象类
     *          10).接口
     *              1.格式: interface 接口名{}
     *              2.作用: 规则定义 提高扩展性
     *              3.成员
     *                  1.成员变量: public static final 修饰
     *                  2.成员方法: public abstract 修饰
     *                  3.jdk8: 静态方法,默认方法  jdk9:私有方法
     *              4.特点:
     *                  1).不能实例化
     *                  2).接口存在的意义让类去实现它
     *              5.关系: 接口与接口: 继承  可以多继承,不可以循环继承
     *                      类与接口: 实现关系 可以多实现
     *                      类与类: 继承
     *      3.多态
     *          1).什么多态:
     *          2).前提: 继承,方法重写,父类引用指向子类对象
     *          3).多态成员关系
     *              名字相同的时候
     *              1.成员变量:   编译看左边,运行看左边
     *              2.成员方法: 编译看左边,运行看右边
     *          4).优缺点:
     *              优点:
     *              缺点:
     *          5).转型
     *              1.向上转型: 小转大,自动转
     *              2.向下转型:大转小 强制转
     *              3.向下转型风险:
     *                  类型不匹配
     *                  instanceof:判断左边的对象是否是右边的类型
     *  3)访问修饰符
     *      private 默认 protected public
     *  4).内部类
     *      在类里面
     *      匿名内部类
     *          格式: new 类名/接口名(参数){重写方法}
     *          本质: 子类的对象
     *  5)常用的api
     *      1.Object
     *          常用方法: toString() equals() hashCode() notify() notifyAll() wait()
     *      2.System
     *          系统工具类
     *             获取当前系统的毫秒值 currentTimeMillis()
     *      3.Math
     *          数学工具类
     *              常用方法:ceil floor abs pow max min round random
     *      4.BigDecimal
     *          精确计算
     *          构造方法: public BigDecimal(String s)
     *          常用方法: add subtract multiply divide
     *              除:省略模式  向上,向下,四舍五入
     *           涉及到钱的
     *      5.包装类
     *          基本类型的对应的引用数据类型
     *          Integer  : parseInt() valueOf()
     *          自动装箱:
     *          自动拆箱:
     *          Byte Short Long Float Double Boolean Character
     *      6.Arrays
     *          数组工具类
     *          toString() 将数组中元素拼接成字符串
     *          sort() 排序
     *3.第三周
     *  1).Date
     *      日期时间类
     *         构造方法: Date()  Date(long ms)
     *         常用方法:setTime() getTime()
     *  2)SimpleDateFormat
     *      简单日期格式化器
     *      格式化和解析日期
     *          构造方法: SimpleDateFormat(String pattern)
     *                 yyyy-MM-dd HH:mm:ss
     *        格式化: format(Date d): 将date对象转成字符串
     *        解析: parse(String date)  将日期型的字符串转成date对象
     *     案例:计算活了多少天?
     *  3).LocalDateTime
     *      日期时间类  jdk8的特性
     *      常用方法:
     *          获取: now() of()
     *          plus系列:加上或减去指定的时间
     *          minus系列: 减去或加上指定的时间
     *          get系列: 获取单独的年,月,日,时,分,秒
     *          with系列:修改
     *          转换:toLocalDate
     *              toLocalTime
     *          格式化和解析
     *              格式化: format(DateTimeFormatter pattern)  传参: DateTimeFormatter .ofPattern("格式")
     *              解析: parse(String date,DateTimeFormatter pattern)
     *  4).集合
     *      1).集合概述
     *          1.体系结构
     *              Collection:
     *                  List:
     *                      ArrayList
     *                          底层:数组
     *                      LinkedList
     *                          底层:链表
     *                  Set:
     *                      HashSet
     *                          数据结构:哈希表
     *                      TreeSet
     *                          数据结构:树
     *                      list和set集合区别
     *                          List:有序,有索引,允许重复
     *                          Set: 无索引,无序,不可重复
     *              Map:双列集合
     *                  HashMap
     *                  TreeMap
     *          2.集合就是一个容器  存储数据
     *            集合和数组的区别
     *      2).Collection集合中方法
     *          增删改查 包含,判断空,清空,长度,迭代器iterator()
     *          遍历: 迭代器  增强for
     *         List中特有方法:
     *              通过索引操作元素  增删改查 indexOf() lastIndexOf()
     *              遍历: 迭代器,增强for,索引for
     *              LinkedList特有方法: addFirst addLast  删第一/最后元素  获取第一个/最后一个元素
     *      3).Map集合方法:
     *          增删改查
     *          keySet()  entrySet()
     *      4).自然排序和比较器排序
     *  5)IO流
     *      1.File
     *          操作文件和文件夹的类
     *          构造方法: File(String pathName) File(String parent,String child)
     *          常用方法:
     *              创建方法:  创建文件,文件夹
     *              删除方法: delete()
     *              获取方法: 获取路径,获取名字,获取父路径,listFiles
     *              判断方法: isFile() isDirectory() exists()
     *          删除一个多级文件夹
     *              递归
     *              套路: 1.进入,2.遍历,3.判断
     *      2.字节流
     *
     *          FileInputStream
     *          FileOutputStream
     *            提高效率
     *              BufferedInputStream
     *              BufferedOutputStream
     *          文件复制 四种方式  字节流: 一次读写一个字节  一次读写一个字节数组
     *                           字节缓冲流:一次读写一个字节  一次读写一个字节数组
     *           读:read() 注意返回值
     *           写:write()
     *       3.字符流:
     *          FileWriter
     *          FileReader
     *           读写的是字符
     *           提高效率
     *              BufferedReader  特有方法: readLine()
     *              BufferedWriter  特有方法:newLine()
     *          字符流=字节流+编码方式
     *       4.转换流
     *          InputStreamReader
     *          OutputStreamWriter
     *           按照指定的编码方式去读写
     *       5.对象操作流
     *          序列化流:ObjectOutputStream
     *              异常: 序列化异常     自定义类实现Serializable接口
     *          反序列化流:ObjectInputStream
     *             异常: 序列号不一致       解决: 声明一个序列号
     *4.第四周
     *  1).网络编程初体验
     *      实现步骤
     *  2).多线程
     *      1.3种实现方法
     *          继承Thread类 实现Runnable接口  实现Callable接口
     *      2.Thread类中方法
     *          线程名字  优先级 休眠   当前线程对象引用
     *      3.线程安全问题
     *          1).使用同步技术解决
     *              1).同步代码块
     *              2).同步方法
     *              3).Lock锁
     *          2).同步的好处和弊端
     *          3)卖票问题
     *      4.生产者和消费者模型
     *          线程协同工作
     *      5.线程的生命周期
     *      6.wait()和sleep()区别
     *
     *
     *
     *
     *
     *
     *
     *
     *
     *
     *
     *
     *
     *
     *
     *
     *
     *
     */
    public static void main(String[] args) {

//        int i=10;
//        byte b=1;
////        b+=2;
////        b=  (b+2);
//        int a=8;
//        int i1 = a >> 3;
//        //a/2^1
//        System.out.println(i1);
//        do{
//            System.out.println("先执行一次再说");
//        }while (true);
//        Random r = new Random();
//        int anInt = r.nextInt(100);
//        System.out.println(anInt);
//        int[] arr = new int[1024];
//        arr.get(0);
//        int[] arr;
//        int arr1[] ;
//        System.out.println("哈哈哈");
//        if(true){
//            return;
//        }
//        while (true){}
//        System.out.println("heiehie");
//        String str="hahah";
//        int h = str.indexOf('a');
//        System.out.println(h);
        int a=128;
        System.out.println((byte)a);
        List<String> list = new ArrayList<>();
    }
}

